home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / msdos / raytrace / pov / gen / geodome / geodome.c next >
C/C++ Source or Header  |  1994-04-28  |  9KB  |  412 lines
  1. #include <math.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5.  
  6. #define TRIANGLE     1
  7. #define MESH        2
  8. #define ERROR         -1
  9. #define VERSION        1
  10. #define INCREMENT    1
  11. #define EMAIL_ADDRESS    "abw@oasis.icl.co.uk"
  12.  
  13.  
  14. /* 
  15.  * geodome.c 
  16.  * 
  17.  * (C) 1994 Andy Wardley (abw@oasis.icl.co.uk).  All Rights Reserved.
  18.  *
  19.  * maths libraray is required.
  20.  * getopt must be provided.
  21.  * 
  22.  */ 
  23.  
  24.  
  25. struct vertex { double x, y, z; };
  26. struct triangle { struct vertex a, b, c; };
  27.  
  28. struct edge 
  29. { 
  30.     struct vertex a, b; 
  31.     struct edge *next;
  32. };
  33.  
  34. struct joint
  35. {
  36.     struct vertex v;
  37.     struct joint *next;
  38. };
  39.  
  40.  
  41. /* default options */
  42. int mode = TRIANGLE;
  43. int rec_depth = 3;
  44. double pipe_radius = 0.01;
  45. double joint_radius = 0.015;
  46. double geodome_radius = 1;
  47.  
  48.  
  49. /* heads of linked lists */
  50. struct edge *first_edge;
  51. struct joint *first_joint;
  52.  
  53.  
  54. /* print usage message */
  55. void usage(void)
  56. {
  57.     printf("GEODOME V%d.%d     Geodome generator for POV-Ray V2.n      23-01-94\n", VERSION, INCREMENT);
  58.     printf("(C) 1994 Andy Wardley <%s>.  All Rights Reserved\n\n", EMAIL_ADDRESS);
  59.     printf("usage:\n\tgeodome [-r depth] [-t | -m [-p radius] [-j radius]]\n\n");
  60.     printf("\t-r depth      recursion depth (default: %i)\n", rec_depth);
  61.     printf("\t-t            generate triangles (default)\n");
  62.     printf("\t-m            generate pipe mesh\n");
  63.     printf("\t-p radius     pipe radius (mesh only) (default: %5.4f)\n", pipe_radius);
  64.     printf("\t-j radius     joint radius (mesh only) (default: %5.4f)\n", joint_radius);
  65.     printf("\nGEODOME may be freely distributed provided it is in its\n");
  66.     printf("original form and has not been modified in any way.\n");
  67. }
  68.  
  69.  
  70. char *basename(char *pathname)
  71. {
  72.     char *ptr;
  73.  
  74.     if ((ptr = strrchr(pathname, '\\')) != NULL)
  75.         return ptr + 1;
  76.     else
  77.         return NULL;
  78. }
  79.  
  80.  
  81.  
  82. /* add a joint to the linked list */
  83. int add_joint(struct vertex *v)
  84. {
  85.     struct joint *new_joint, *j;
  86.     
  87.     /* allocate memory for a new joint */
  88.     if ((new_joint = (struct joint *) malloc (sizeof(struct joint)))
  89.         == (struct joint *) NULL)
  90.     {
  91.         fprintf(stderr, "Out of memory\n");
  92.         return 1;
  93.     }
  94.  
  95.     /* load values and set fwd pointer to NULL */
  96.     new_joint->v = *v;
  97.     new_joint->next = (struct joint *) NULL;
  98.     
  99.     /* check for an empty list */
  100.     if (first_joint == (struct joint *) NULL)
  101.         first_joint = new_joint;
  102.     else
  103.     {
  104.         j = first_joint;
  105.  
  106.         /* traverse existing linked list */
  107.         for (;;)
  108.         {
  109.             /* forget duplicates */
  110.             if (memcmp(&j->v, &new_joint->v, sizeof(struct vertex)) == 0)
  111.             {
  112.                 free(new_joint);
  113.                 return 0;
  114.             }
  115.  
  116.             /* if at end of list, add new joint */
  117.             if (j->next == (struct joint *) NULL)
  118.             {
  119.                 j->next = new_joint;
  120.                 return 0;
  121.             }
  122.  
  123.             /* next list element */
  124.             j = j->next;            
  125.         }
  126.     }
  127.         
  128.     return 0;
  129. }
  130.  
  131.  
  132. /* add an edge to the linked list */
  133. int add_edge(struct vertex *a, struct vertex *b)
  134. {
  135.     struct edge *new_edge, *e;
  136.     
  137.     /* allocate memory for a new joint */
  138.     if ((new_edge = (struct edge *) malloc(sizeof(struct edge)))
  139.         == (struct edge *) NULL)
  140.     {
  141.         fprintf(stderr, "Out of memory\n");
  142.         return 1;
  143.     }
  144.  
  145.     /*
  146.     load the new structure with the data.  We always make sure that 
  147.     new_edge->a gets the smaller value (reason given below)
  148.     */ 
  149.     if (memcmp(a, b, sizeof(struct vertex)) < 0)
  150.     {
  151.         new_edge->a = *a;
  152.         new_edge->b = *b;
  153.     }
  154.     else
  155.     {
  156.         new_edge->a = *b;
  157.         new_edge->b = *a;
  158.     }
  159.  
  160.     /* set fwd pointer to NULL */
  161.     new_edge->next = (struct edge *) NULL;
  162.     
  163.     /* check for an empty linked list */
  164.     if (first_edge == (struct edge *) NULL)
  165.         first_edge = new_edge;
  166.     else
  167.     {
  168.         e = first_edge;
  169.  
  170.         /* traverse existing linked list */
  171.         for (;;)
  172.         {
  173.             /*
  174.             here we compare new element against existing
  175.             list elements.  If we find a match, we don't
  176.             need to add it again.  This is why we always
  177.             put the smallest value in a, otherwise, we   
  178.                wouldn't find the match if the ends were swapped.  
  179.             */
  180.             if (memcmp(&e->a, &new_edge->a, sizeof(struct vertex)) == 0
  181.                 && memcmp(&e->b, &new_edge->b, sizeof(struct vertex)) == 0)
  182.             {
  183.                 free(new_edge);
  184.                 return 0;
  185.             }
  186.  
  187.             /* add the edge if we've got to the end of the list */
  188.             if (e->next == (struct edge *) NULL)
  189.             {
  190.                 e->next = new_edge;
  191.                 return 0;
  192.             }
  193.  
  194.             /* next list item */
  195.             e = e->next;            
  196.         }
  197.     }
  198.         
  199.     return 0;
  200. }
  201.  
  202.  
  203. /* add the three joints and edges for a given triangle */
  204. int add_triangle(struct triangle *t)
  205. {
  206.     if (add_joint(&t->a) != 0)
  207.         return ERROR;
  208.     if (add_joint(&t->b) != 0)
  209.         return ERROR;
  210.     if (add_joint(&t->c) != 0)
  211.         return ERROR;
  212.     if (add_edge(&t->a, &t->b) != 0)
  213.         return ERROR;
  214.     if (add_edge(&t->b, &t->c) != 0)
  215.         return ERROR;
  216.     if (add_edge(&t->c, &t->a) != 0)
  217.         return ERROR;
  218. }
  219.  
  220.  
  221. /* returns the mid-point of two vertices (extended to geodome radius) */
  222. struct vertex average(struct vertex *v1, struct vertex *v2)
  223. {
  224.     struct vertex m;
  225.     double hypot, ratio;
  226.  
  227.     m.x = (v1->x + v2->x) / 2;
  228.     m.y = (v1->y + v2->y) / 2;
  229.     m.z = (v1->z + v2->z) / 2;
  230.  
  231.     hypot = sqrt(pow(m.x, 2) + pow(m.y, 2) + pow(m.z, 2));
  232.     ratio = geodome_radius / hypot;
  233.  
  234.     m.x *= ratio;
  235.     m.y *= ratio;
  236.     m.z *= ratio;
  237.  
  238.     return m;
  239. }
  240.  
  241.  
  242. /* sub-divide a triangle into 4 smaller triangles */
  243. void divide_triangle(struct triangle *t, int depth)
  244. {
  245.     struct triangle new_t[4];
  246.     int subt;
  247.  
  248.     new_t[0].a = t->a;
  249.     new_t[1].b = t->b;
  250.     new_t[2].c = t->c;
  251.  
  252.     new_t[0].c = new_t[2].a = new_t[3].b = average(&(t->a), &t->c);
  253.     new_t[0].b = new_t[1].a = new_t[3].c = average(&t->a, &t->b);
  254.     new_t[1].c = new_t[2].b = new_t[3].a = average(&t->c, &t->b);
  255.  
  256.     /* recurse if depth not yet reached */
  257.     if (--depth != 0)
  258.         for(subt = 0; subt < 4; subt++)
  259.             divide_triangle(&new_t[subt], depth);
  260.     else
  261.     {
  262.         /* 
  263.         dump triangle data or add to linked lists, depending
  264.         on the type of geodome
  265.         */
  266.         for(subt = 0; subt < 4; subt++)
  267.         {
  268.             if (mode == TRIANGLE)
  269.                 printf("\ttriangle {\n\t\t<%.10f, %.10f, %.10f>\
  270. \n\t\t<%.10f, %.10f, %.10f>\n\t\t<%.10f, %.10f, %.10f>\n\t}\n",
  271.                     new_t[subt].a.x, new_t[subt].a.y, new_t[subt].a.z, 
  272.                     new_t[subt].b.x, new_t[subt].b.y, new_t[subt].b.z, 
  273.                     new_t[subt].c.x, new_t[subt].c.y, new_t[subt].c.z);
  274.             else
  275.                 add_triangle(&new_t[subt]);
  276.         }
  277.     }
  278. }
  279.  
  280.  
  281.  
  282. void main(int argc, char **argv)
  283. {
  284.     char ch;
  285.     struct triangle t;
  286.     struct joint *j;
  287.     struct edge *e;
  288.  
  289.     /* zero linked list */
  290.     first_edge = NULL;
  291.     first_joint = NULL;
  292.     
  293.     /* read command line */
  294.     while ((ch = getopt(argc, argv, "tmr:p:j:")) != EOF)
  295.     {
  296.         switch(ch)
  297.         {
  298.             case 't':
  299.                 mode = TRIANGLE;
  300.                 break;
  301.  
  302.             case 'm':
  303.                 mode = MESH;
  304.                 break;
  305.  
  306.             case 'r':
  307.                 rec_depth = atoi(optarg);
  308.                 if (rec_depth == 0)
  309.                 {
  310.                     fprintf(stderr, "%s: invalid recursion depth\n",
  311.                              basename(argv[0]));
  312.                     exit(1);
  313.                 }
  314.                 break;
  315.  
  316.             case 'p':
  317.                 pipe_radius = atof(optarg);
  318.                 if (pipe_radius == 0)
  319.                 {
  320.                     fprintf(stderr, "%s: invalid pipe radius\n",
  321.                              basename(argv[0]));
  322.                     exit(1);
  323.                 }
  324.                 break;
  325.  
  326.             case 'j':
  327.                 joint_radius = atof(optarg);
  328.                 if (joint_radius == 0)
  329.                 {
  330.                     fprintf(stderr, "%s: invalid joint radius\n",
  331.                              basename(argv[0]));
  332.                     exit(1);
  333.                 }
  334.                 break;
  335.  
  336.             case '?':
  337.                 usage();
  338.                 exit(1);
  339.                 break;
  340.         }
  341.     }
  342.  
  343.     /* setup the parent triangle */
  344.     t.a.x = t.b.x = 0;
  345.     t.b.y = t.c.y = 0;
  346.     t.a.z = t.c.z = 0;
  347.     t.c.x = geodome_radius;
  348.     t.a.y = geodome_radius;
  349.     t.b.z = geodome_radius;
  350.  
  351.     /* print some stats */
  352.     fprintf(stderr, "recursion depth: %i\n", rec_depth);
  353.     fprintf(stderr, "           mode: %s\n", mode == TRIANGLE ? "triangles" : "mesh");
  354.     if (mode == MESH)
  355.     {
  356.         fprintf(stderr, "    pipe radius: %5.4f\n", pipe_radius);
  357.         fprintf(stderr, "   joint radius: %5.4f\n", joint_radius);
  358.     }
  359.         
  360.  
  361.     printf("/* model data created by geodome V%d.%d  */\n", VERSION, INCREMENT);
  362.     printf("/* by Andy Wardley <%s> */\n\n", EMAIL_ADDRESS);
  363.     printf("#declare geodome_eighth =\nunion {\n");
  364.     divide_triangle(&t, rec_depth);
  365.  
  366.     if (mode == MESH)
  367.     {
  368.         printf("//\tjoints\n");
  369.  
  370.         /* traverse joint list, printing and free as we go */
  371.         while (first_joint != (struct joint *) NULL)
  372.         {
  373.             j = first_joint;
  374.             first_joint = first_joint->next;
  375.             printf("\tsphere { <%.10f, %.10f, %.10f> %5.4f }\n", 
  376.                 j->v.x, j->v.y, j->v.z, joint_radius);
  377.             free(j);
  378.         }
  379.  
  380.         printf("\n//\tedges\n");
  381.  
  382.         /* traverse edge list, printing and freeing as we go */
  383.         while (first_edge != (struct edge *) NULL)
  384.         {
  385.             e = first_edge;
  386.             first_edge = first_edge->next;
  387.             printf("\tcone {\n");
  388.             printf("\t\t<%.10f, %.10f, %.10f> %5.4f\n", 
  389.                 e->a.x, e->a.y, e->a.z, pipe_radius);
  390.             printf("\t\t<%.10f, %.10f, %.10f> %5.4f\n\t}\n", 
  391.                 e->b.x, e->b.y, e->b.z, pipe_radius);
  392.             free(e);
  393.         }
  394.     }
  395.     
  396.     printf("}\n");
  397.  
  398.     /* finally create some complete geodome hemispheres and spheres */
  399.     printf("\n\n#declare geodome_hemisphere = \nunion {\n");
  400.     printf("\tobject { geodome_eighth }\n");
  401.     printf("\tobject { geodome_eighth rotate <0, 90, 0> }\n");
  402.     printf("\tobject { geodome_eighth rotate <0, 180, 0> }\n");
  403.     printf("\tobject { geodome_eighth rotate <0, 270, 0> }\n");
  404.     printf("}\n");
  405.     
  406.     printf("\n\n#declare geodome = \nunion {\n");
  407.     printf("\tobject { geodome_hemisphere }\n");
  408.     printf("\tobject { geodome_hemisphere rotate <180, 0, 0> }\n");
  409.     printf("}\n");
  410. }
  411.  
  412.